/**

 * User: seeker910
 * Date: 13-11-1
 * Time: 上午3:45

 */

/**
 * @memberof Rsd.data
* */
Rsd.define('Rsd.data.Ajax', {
    extend:'Rsd.common.Object',
    xtype:'ajax',
    method: 'POST',
    url: null,
    /*
    * 'text/plain'
    * 'application/json; charset=utf-8'：以json字符串形式发送，格式如：userid=admin&pwd=654321 需要服务端JSON.parse 还原JSON
    * 'application/x-www-form-urlencoded;charset=UTF-8'：以formData 格式发送，将表单内的数据转换为键值对，如:name=jack&age=18
    * 'multipart/form-data':既可以上传文件等二进制数据，也可以上传表单键值对，只是最后会转化为一条信息,使用boundary=xxxxxxx分割
    * */
    contentType: 'application/x-www-form-urlencoded;charset=UTF-8',
    /**
     * 预期服务器返回的数据类型:text,json
     */
    dataType: 'json',
    async: true,
    /**
     * 超时时间 毫秒
     */
    timeout:10000,
    username: '',
    password: '',
    /**
     * 是否是跨域请求
     * */
    crossDomain:true,
    /**
    * @description Ajax请求客户端标识，作用域：每个客户端, 添加到header中
    * */
    appId:'',
    /**
     * @description Ajax请求身份标识，作用域：每次请求, 添加到header中
     * * */
    token:'',
    /**
     * @description 授权码
     */
    authCode:'',
    /**
     * @description 返回数据json格式：web:首字母小写
     */
    jsonFormatter:null,
    /**
     * @constructs Rsd.data.Ajax
     * @classdesc Ajax请求类
     *
     * @property  {string} extend Rsd.common.Object
     * @property  {string} xtype ajax
     * @property {EventList} events 事件列表
     * @property {string} method GET，POST，PUT，DELETE
     * @property {string} url
     * @property {string} contentType application/x-www-form-urlencoded; charset=UTF-8
     * @property {string} dataType text，json
     * @property {boolean} async false
     * @property {string} username
     * @property {string} password
     * @property {string} appId
     * @property {string} token
     * @property {string} authCode
     *
     * @param {object} config 自定义配置项
     * */
    constructor: function Ajax (config) {
        config = config || {}; 
        this.apply(config);
    },
    /**
     * @description 事件注册
     * @public
     * @function
     * @memberof Rsd.data.Ajax
     * */
    on: function on(name, fn) {

        if (!name || name == '') {
            throw new Error('argument \'name\' is null.');
        }
        if (!fn || typeof (fn) != 'function') {
            throw new Error('on ['+name+'] event failed ,argument \'fn\' is not a function object.');
        }
        //var me = this;

        this.events.add(this, name, fn);
    },
    /**
     * 
     */
    statechange:function statechange(xhr, evt)
    {
         /*
            xhr.readyState =（0，1，2，3，4）
            0：请求未初始化，还没有调用 open()。
            1：请求已经建立，但是还没有发送，还没有调用 send()。
            2：请求已发送，正在处理中（通常现在可以从响应中获取内容头）。
            3：请求在处理中；通常响应中已有部分数据可用了，没有全部完成。
            4：响应已完成；您可以获取并使用服务器的响应了。
        */
        Rsd.debug('statechange: ['+this.url+']' + ' | readyState:' + xhr.readyState +  ' | status:' + xhr.status);
    },
    /**
     * @public
     * @function
     * @memberof Rsd.data.Ajax
     * */
    complete:function complete(xhr, evt)
    {
        Rsd.debug('request complete:['+this.url+']');
    },

    /**
     * @public
     * @function
     * @memberof Rsd.data.Ajax
     * @param {XmlHttpRequest}  xhr 
     * @param {string} error
    * */
    error:function error(xhr, evt){
 
        Rsd.debug('request error:['+this.url+'] (' + (xhr.textStatus||xhr.status ||'') + ')');

        if(xhr.status == 404)
        {
            Rsd.showModalDialog(this.url,'服务器资源不存在(404)',400,500);
            return false;
        }

        if(xhr.status == 405)
        {
            Rsd.alert("Http请求不允许使用方法-"+this.method+"(405)","请检查该Ajax请求Method属性的设置\r\n" + this.url + "\r\n");
            return false;
        }

        console.error('Ajax请求失败('+(xhr.textStatus||xhr.status ||'unknown code')+'):',this.url,evt);
    },
    /**
     * @description 请求成功（status == 200） 处理方法，仅在 request方法未指定callback参数时有效
     * @public
     * @function
     * @memberof Rsd.data.Ajax
    * */
    success:function success(xhr) {
        Rsd.debug('request success:[' + this.url + ']');
    },
 
    /**
     * @public
     * @function
     * @memberof Rsd.data.Ajax
     * @description http请求,返回json结构数据
     * @param {object} data 作为Ajax对象请求时的参数中data属性（即远程方法的参数）
     * @param {string|function} callback 回调函数，callback方法和对象success方法只有一个有效，优先使用callback。callback需求每次请求时指定，success对象属于，不需要每次请求指定
    * */
    request:function request(data,callback) {

        var me = this;
        var _c = this.getAjaxConfig();  
        if(Rsd.isEmpty(_c.url))
        {
            console.error('Ajax config is error',_c);
            throw new Error('Ajax object config url value  is null.');
        }
 
        _c.data = data;
        _c.xhrFields={
            withCredentials:_c.crossDomain==false
        };
        //beforeSend 在xhr.open 之后 ，xhr.send 之前 执行
        _c.beforeSend = function(xhr)
        {   
            //框架可扩展部分 
            //xhr.withCredentials = true; //指示跨域时是否包含 cookies
            //setRequestHeader(name,value)添加http 头,必须在  xhr.open 之后 ， 在跨域请求时 {name}需要在后端设置允许跨域设置 
            if(_c.contentType && _c.contentType != "multipart/form-data")
            {
                xhr.setRequestHeader("Content-type", _c.contentType);//不设置默认值，以免影响文件上传
            }
            
            xhr.setRequestHeader("accept-language",window.navigator.language); 
            if(_c.token)
            {
                xhr.setRequestHeader('token', _c.token);
            }
            if(_c.appId)
            {
                xhr.setRequestHeader('appId', _c.appId);
            }
            if(_c.authCode)
            {
                xhr.setRequestHeader('authorization', _c.authCode);
            }
            if(_c.jsonFormatter)
            {
                xhr.setRequestHeader('x-json-formatter', _c.jsonFormatter);
            }
            if(_c.accept)
            {
                xhr.setRequestHeader('accept', _c.accept);
            }
            //设置其他header信息
            xhr.setRequestHeader('X-Requested-With','XMLHttpRequest')
        }

        if(callback)
        {
            //callback 替换了  ajax对象中的success
            _c.success = function(response){
                
                var _data = response;
                if(Rsd.isFunction(callback))
                {
                    return callback.call(me,_data);
                }
                if(Rsd.isString(callback))
                {
                    return me.funApplyByIOC(callback,[_data]);
                }
                console.warn('callback is not functon',callback);
            };
        }

        if(Rsd.app && Rsd.app.appType=='wxapp' && wx && wx.request)
        {
            return wx.request(_c);
        }
       
        var type = _c.method.toUpperCase();
        // 发送GET请求
        if(type == 'GET'){
            
            this.get();
            return;
        }

        // 发送 POST请求
        if(type == 'POST' || type == 'PUT' || type == 'PATCH' || type == 'DELETE'){

            this.post();
            return; 
        } 

        throw new Error("Unkown Method: " + _c.method);
         
    },
     
    /**
     * 
     */
    get:function get()
    {
        var _c = this.getAjaxConfig() ||{};
        var xhr = this.getXhr();
        // 用于清除缓存
        var random = Math.random(); 
        var _async = _c.async == undefined ? true : _c.async;
        
        
        if(Rsd.isEmpty(_c.data)){
            xhr.open('GET', _c.url + (_c.url.endWith('.js') ?('?t='+ random):''),_async );
        } 
        else 
        {
            var _data = "";
            _data = this.toFormDataString(_c.data); 
            xhr.open('GET', _c.url + (_c.url.indexOf('?')<0?'?':'&') + _data, _async);
        }
         
        // 在 open 之后 ，处理 beforeSend 
        _c.beforeSend.call(xhr.ajax,xhr);
         if(false)
        {
            //设置超时时间
            xhr.timeout = (_c.timeout == null || _c.timeout == undefined) ? 10000 : _c.timeout; 
        }
        //注册异步处理事件
        if(_async) { 
      
            //处理返回数据
            xhr.onreadystatechange = function(evt){
                
                /*
                    xhr.readyState =（0，1，2，3，4）
                    0：请求未初始化，还没有调用 open()。
                    1：请求已经建立，但是还没有发送，还没有调用 send()。
                    2：请求已发送，正在处理中（通常现在可以从响应中获取内容头）。
                    3：请求在处理中；通常响应中已有部分数据可用了，没有全部完成。
                    4：响应已完成；您可以获取并使用服务器的响应了。
                */
                if(xhr.readyState == 4){
                    //处理同步返回结果
                    _c.response.call(xhr.ajax,xhr); 
                   
                }

                //跟踪状态
                if (Rsd.isFunction(_c.statechange)) {
                    _c.statechange.call(xhr.ajax,xhr, evt);
                }
            }
        }
        try
        {
            xhr.send();
        }
        catch(err)
        {
            _c.error.call(xhr.ajax,xhr,err);
        }

        //处理返回
        if(_async)
        {
            //异步 ,不做处理，通过onreadystatechange事件处理
        }
        else 
        {
            //处理同步返回结果
            _c.response.call(xhr.ajax,xhr); 
        }
    },

    /**
     * 
     * @param {*} data 
     * @param {*} callback 
     */
    post:function post()
    {
        var _c = this.getAjaxConfig() ||{};
        var xhr = this.getXhr();
        var type = _c.method;
        var _async = _c.async == undefined ? true : _c.async;
        //
        xhr.open(type, _c.url,_async);

        //在 open 之后 ，处理 beforeSend 
        _c.beforeSend(xhr);
        
       var _data = _c.data;
       //以json字符串形式发送，格式如：userid=admin&pwd=654321， 需要服务端JSON.parse 还原JSON
       if(_c.contentType == "application/json")
       { 
           _data = this.toJsonString(_c.data);
       }
       //以formData 格式发送，将表单内的数据转换为键值对，如:name=jack&age=18
       if(_c.contentType == "application/x-www-form-urlencoded")
       {
           if(!Rsd.isType(_c.data, FormData))
           {
               //form 提交 
               _data = this.toFormDataString(_c.data); 
           } 
       }
       
       //既可以上传文件等二进制数据，也可以上传表单键值对，最后会转化为一条信息
       if(_c.contentType == "multipart/form-data")
       {  
           if(!Rsd.isType(_c.data, FormData))
           { 
               _data = this.toMultipartFormData(_c.data);//json 对象转化为FormData
           } 
       }
       if(false)
       {
            //设置超时时间
            xhr.timeout = (_c.timeout == null || _c.timeout == undefined) ? 10000 : _c.timeout; 
       }
        
       //注册异步处理事件
       if(_async) {
              
            //console.log( xhr.timeout);
            //处理返回数据
            xhr.onreadystatechange = function(evt){
 
                /*
                    xhr.readyState =（0，1，2，3，4）
                    0：请求未初始化，还没有调用 open()。
                    1：请求已经建立，但是还没有发送，还没有调用 send()。
                    2：请求已发送，正在处理中（通常现在可以从响应中获取内容头）。
                    3：请求在处理中；通常响应中已有部分数据可用了，没有全部完成。
                    4：响应已完成；您可以获取并使用服务器的响应了。
                */
               
                if(xhr.readyState == 4){
                    //处理同步返回结果 
                    _c.response.call(xhr.ajax,xhr); 

                }
                //跟踪状态
                if (Rsd.isFunction(_c.statechange)) {
                    
                    _c.statechange.call(xhr.ajax,xhr,evt);
                }

            }
        }

       try
       {
           xhr.send(_data);
       }
       catch(err)
       { 
            //console.error('here is error',err);
           _c.error.call(xhr.ajax,xhr, err);
       }
       //处理返回
       if(_async)
        {
            //异步 ,不做处理，通过onreadystatechange事件处理 
            //console.log('异步');
        }
        else 
        { 
             //处理同步返回结果
            _c.response.call(xhr.ajax,xhr);
        } 
    },
   
    
    /**
     * 处理 返回结果
     * @param {*} xhr 
     * @returns 
     */
    response:function response(xhr)
    {
        var _c = this.getAjaxConfig() ||{};
        //返回结果
        var str = xhr.responseText;
        /*
        * xhr.status
        * 200——成功
        * 201——提示知道新文件的URL
        * 300——请求的资源可在多处得到
        * 301——删除请求数据
        * 404——没有发现文件、查询或URl
        * 500——服务器产生内部错误
        * */ 
        if(xhr.status == 200)
        {
            var data=str;
            //console.log(_c,xhr);
            if(_c.dataType == 'json')
            {
                try 
                {
                    data = Rsd.toJson(str);
                }
                catch (err) 
                { 
                    console.error('respone data is not json',err);
                }
            }
            
            if (Rsd.isFunction(_c.success))//指请求成功，未发生异常：404，timeout
            {
                _c.success.call(xhr.ajax,data);
               
            }

            return;
        }

        if(xhr.status >= 500) //服务端异常
        {

            if (Rsd.isFunction(_c.error)) {
                _c.error.call(xhr.ajax,xhr);
                return;
            }  
           
        }
 
        Rsd.debug('----------request [' + xhr.ajax.url + '] error----------');
        Rsd.debug('xhr readyState is ' + xhr.readyState + ', xhr status is :' + xhr.status + ', xhr respone is :' + (str||'-')); 
        Rsd.debug('----------error end----------');
        
    },
    /**
     * 
     * @returns 
     */
    getXhr:function getXhr()
    {
        var _c = this.getAjaxConfig() ||{type:'GET', url:'', data:null, success:null, failed:null};
        _c.method = _c.method||_c.type|| this.method ||'GET';

        // 创建ajax对象
        var xhr = null;
        if(window.XMLHttpRequest){
            xhr = new XMLHttpRequest();
        } 
        if(xhr==null && typeof ActiveXObject !=='undefined')  {
            xhr = new ActiveXObject('Microsoft.XMLHTTP')
        }
        if(xhr==null)
        {
            return;
        }
        //可注册事件
        //     loadstart:在接收到响应数据的第一个字节时触发 
        // 　　progress:在接收响应期间持续不断地触发
        // 　　error:在请求发生错误时触发 
        // 　　abort:在因为调用abort()方法而终止连接时触发 
        // 　　load:在接收到完整的响应数据时触发 
        // 　　loadend:在通信完成或者触发error、abort或load事件后触发 
        // 　　timeout:超时发生时触发
        //     onreadystatechange
         
         xhr.ajax = this;
         //注册跟踪事件 对接外部事件注册
         xhr.addEventListener('loadstart', _c.handleEvent);
         xhr.addEventListener('load', _c.handleEvent);
         xhr.addEventListener('loadend', _c.handleEvent);
        
         xhr.addEventListener('error', _c.handleEvent);
         xhr.addEventListener('abort', _c.handleEvent);
         xhr.addEventListener('timeout', _c.handleEvent);
          //下载进度
         xhr.addEventListener('progress', _c.handleEvent);
 
         //注册跟踪上传事件  对接外部事件注册
         if(xhr.upload)
         {
            xhr.upload.ajax = this;
            //上传开始
            xhr.upload.addEventListener('loadstart', _c.handleUploadEvent);
            //上传成功
            xhr.upload.addEventListener('load', _c.handleUploadEvent);
            //上传已经停止
            xhr.upload.addEventListener('loadend', _c.handleUploadEvent); 
            //上传失败
            xhr.upload.addEventListener('error', _c.handleUploadEvent);
            //上传终止
            xhr.upload.addEventListener('abort', _c.handleUploadEvent);
            //由于预设时间到期，上传终止
            xhr.upload.addEventListener('timeout', _c.handleUploadEvent); 
            //上传进度
            xhr.upload.addEventListener("progress" , _c.handleUploadEvent , false); 
         } 
        // xhr.onabort  
        // xhr.onload 
        //
        // xhr.onloadstart 
        // xhr.onprogress 

        //在请求中注册
        // xhr.onreadystatechange  

        //完成
        xhr.onloadend = function(evt)
        {
            if (Rsd.isFunction(_c.complete))
            {
                _c.complete(xhr,xhr.ajax.url,evt);

            }else
            {
                Rsd.debug('-----complete ' + xhr.ajax.url + '------');
                Rsd.debug('event type:' + evt.type + ', readyState:' + evt.target.readyState + ', timeout:' +  evt.target.timeout);
                Rsd.debug('-----complete end ------');
            }
        };
        //超时
        xhr.ontimeout = function (evt) {

            //框架可扩展部分 timeout
            if (Rsd.isFunction(_c.timeout))
            {
                _c.timeout(xhr,evt);

            }else
            {
                Rsd.debug('-----timeout ' + xhr.ajax.url + '------');
                Rsd.debug('event type:' + evt.type + ', readyState:' + evt.target.readyState + ', timeout:' +  evt.target.timeout);
                Rsd.debug('-----timeout end ------');
            }

        };
        //错误
        xhr.onerror = function (evt) {

            if (Rsd.isFunction(_c.error)) { 
                _c.error(xhr, evt); 
            } 
            else
            {
                Rsd.debug('-----error ' + xhr.ajax.url + '------');//console.log(evt)
                Rsd.debug('event type:' + evt.type + ', readyState:' + evt.target.readyState + ', timeout:' +  evt.target.timeout);
                Rsd.debug('-----error end ------');
            }
        };
 
        return xhr;
    },
    /**
     * @public
     * @function
     * @description 获取当前ajax的配置项
     * @memberof Rsd.data.Ajax
    * */
    getAjaxConfig:function getAjaxConfig() {
        if(this.__cache)
        {
            return this.__cache;
        }
        //当前对象的克隆版
        var _c = {};
        var _keys = [
            'appId',
            'token',
            'authCode',
            'jsonFormatter',
            'method',
            'url',
            'accept', 
            'contentType',
            'dataType',  
            'data',
            'async',
            'username',
            'password', 
            'statechange',
            'complete',
            'error',
            'success',
            'timeout',
            'response',
            'handleEvent',
            'handleUploadEvent'
        ];

        for(var i in _keys)
        {
            if(_keys.hasOwnProperty(i))
            {
                if(i == "data")
                {
                    _c[_keys[i]] = this[_keys[i]];
                    continue;
                }
                _c[_keys[i]] = Rsd.clone(this[_keys[i]]);
            }

        }
        if(!Rsd.isString(_c.url))
        {
            console.error('args url is not string value.');
            console.trace(_c);
            return _c;
        }
        /*
        if(this.key && _c.url && !_c.url.toLowerCase().startWith(Rsd.getRedjsHost().toLowerCase()))
        {
            _c.url = _c.url + (_c.url.indexOf('?')> 0? '&':'?') + '___key=' + this.key;
        }
        */

        var _url = _c.url;
        if(_url.startWith('http://') || _url.startWith('https://')||_url.startWith('file://'))
        {}
        else
        {
            //只处理相对路径
            _url = (Rsd.app&&Rsd.app.jsAgentHost)?(Rsd.app.jsAgentHost+'?' + Rsd.utf8ToBase64(_url)):_url;
            _c.url = _url;
        }
        //console.log(_c);
        //缓存
        this.__cache = _c;
        return this.__cache;
    },

    /**
     * 重置config ,删除缓存
     */
    resetAjaxConfig:function resetAjaxConfig()
    {
        delete this["__cache"];
    },
    /**
     * @decription 对接所有请求（不包括上传事件）事件，使用时通过on(name,fn)注册方式 各事件响应
     * @param {*} evt 
     */
    handleEvent:function handleEvent(evt)
    {
        var me = this.ajax;
        me.events.fire(me,evt.type,[evt]);
        if(Rsd.isDebug)
        {
            console.debug('['+evt.type+']' + evt.currentTarget.responseURL,evt);
        }
        
    },
    /**
     * @decription 对接所有上传事件，使用时通过on(name,fn)注册方式 各事件响应 ，name为'upload'+事件名
     * @param {*} evt 
     */
    handleUploadEvent:function handleUploadEvent(evt)
     {
        var me = this.ajax;
        me.events.fire(me,'upload' + evt.type,[evt]);
        if(Rsd.isDebug)
        {
            console.debug('上传['+evt.type+']'+ evt.currentTarget.responseURL,evt.type,evt);
        }
          
     },
    /**
    * 以json字符串形式发送，格式如：userid=admin&pwd=654321， 需要服务端JSON.parse 还原JSON
    * @param {*} data 
    * @returns 
    */
   toJsonString:function toJsonString(data)
   {
       return Rsd.toString(data);
   },
   /**
     * 组织 form 属性 EncType（content-type）为 application/x-www-form-urlencoded 提交数据
     * 以formData 格式发送，将表单内的数据转换为键值对，如:name=jack&age=18
     * @param {*} obj 
     * @param {*} pre 
     */
   toFormDataString:function toFormDataString(obj,pre) {

       
        var _pre = pre || '';
        if (obj == undefined || obj==null) {

            return '';
        }

        if (typeof obj == "string") {
            if(_pre)
            {
                return _pre +"=" + obj.replace(/([\"\\])/g, "\\$1").replace(/(\n)/g, "\\n").replace(/(\r)/g, "\\r").replace(/(\t)/g, "\\t") + "";
            }
            else
            {
                return "" + obj.replace(/([\"\\])/g, "\\$1").replace(/(\n)/g, "\\n").replace(/(\r)/g, "\\r").replace(/(\t)/g, "\\t") + "";
            }
           
        }

        if (obj instanceof Array) {
            var r = [];
            for (var i = 0; i < obj.length; i++) {
                if (typeof (obj[i]) == 'function') {

                    continue;
                }
                if (typeof obj[i] == 'object') {
                    var _t = this.toFormDataString(obj[i], _pre + '[' + i + ']');
                    Array.prototype.push.apply(r, _t);
                }
                else {
                    r.push(this.toFormDataString(obj[i], _pre + '[' + i + ']'))
                }
               

                if (!_pre) {
                    r = r.join('&');
                }
            }
            
            //非对象类型的数组 没有处理为:[1,24,5] 格式

            return r;
        }

        if (typeof obj == "object") {
            var r = [];

            for (var k in obj) {
                if (typeof (obj[k]) == 'function') {
                    continue;
                }
                if ( obj[k]==null || typeof  obj[k] == "string") {

                    if(_pre)
                    {
                        r.push(_pre + '[' + k + ']' + "=" +  this.toFormDataString(obj[k]));
                    }else
                    {
                        r.push(k + "=" +  this.toFormDataString(obj[k]));
                    }
                    continue;
                }
                 
                if(typeof obj[k] == 'object' )
                { 
                    if(_pre)
                    {
                        var _t = this.toFormDataString(obj[k],_pre + '[' + k + ']');
                        Array.prototype.push.apply(r , _t);
                    }else
                    {
                        var _t = this.toFormDataString(obj[k], k);
                        Array.prototype.push.apply(r , _t);
                    }
                }
                else
                {
                    if(_pre)
                    {
                        r.push(_pre + '[' + k + ']' + "=" +  this.toFormDataString(obj[k]));
                    }else
                    {
                        r.push(k + "=" +  this.toFormDataString(obj[k]));
                    }

                }

            }
            if(!_pre)
            {
                r = r.join('&');
            }
            //console.log(r);
            return r;
        }

        return obj.toString().replace(/\"\:/g, '":""');
    },
    
   /**
    * 将json 数据转化为FormData
    * multipart/form-data
    * 既可以上传文件等二进制数据，也可以上传表单键值对，最后会转化为一条信息
    */
   toMultipartFormData:function toMultipartFormData(data)
   {
       var _data = data||{};
       var formData = new FormData();
       //debugger;
       for(var i in _data)
       {
           var _d = _data[i];
           if(Rsd.isArray(_d))
           {
              for(var j in _d)
              {
                  formData.append(i + '['+j+']' , _d[j]);
                  //console.log('this code ajax in file',i+ '['+j+']',_d[j]);
              }
              continue;
           }

           if(Rsd.isType(_d,File))
           {  
               formData.append(i,_d,_d.name);
               continue;
           }
           formData.append(i,_d);
       } 
       
       return formData;
   }

},function (type) {

    if (!Rsd.data.Ajax.prototype.hasOwnProperty("events")) {
        var _eventsGetter = function () {
            var _me = this;
            if (_me.__events == null) {
                _me.__events = Rsd.create('Rsd.common.EventList', {});
            }
            return  _me.__events;
        };

        this.defineProperty(type,"events", _eventsGetter, null,true);

    }
});

